package part14;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author wcj
 * @Date 2021/5/26 16:45
 * @Version 1.0
 */
public class Part1413 {

    public static void consumer(Interface face) {
        face.doSomething();
        face.doSomethingElse("kkk");
    }

    public static void main(String[] args) {
        RealObject realObject = new RealObject();
//        consumer(realObject);
        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(), new Class[]{Interface.class}, new DynamicProxyHandler(realObject));
        consumer(proxy);
    }
}

/**
 * Java提供动态代理，即通过创建动态代理，将调用重定向到调用处理器
 * 实际上动态代理看的更明显，即将我们想要代理的接口，接口中想要被代理的方法接口列表，调用处理器传入构造成为代理对象，并且转型成为我们需要的对象，然后方法调用传入
 * 这样调用的方法被重载到调用处理器进行执行
 */
class DynamicProxyHandler implements InvocationHandler {

    private Object proxied;

    public DynamicProxyHandler(Object proxy) {
        this.proxied = proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy:" + proxy.getClass() + ",method:" + method + ",args:" + args);
        if (args != null) {
            for (Object arg : args) {
                System.out.println("" + arg);
            }
        }
        return method.invoke(proxied, args);
    }
}
